src/libs/CSharpToJsonSchema.Generators/Sources.Method.Calls.cs (1)

30-63: 🛠️ Refactor suggestion

Possible key lookup risk in AsCalls().

Delegates["{method.Name}"] is directly accessed with no checks, potentially causing a KeyNotFoundException. Consider adding a safety check or fallback.

src/libs/CSharpToJsonSchema.Generators/Conversion/SymbolGenerator.cs (1)

99-151: New method for generating JSON serializer context for tools.

The GenerateToolJsonSerializerContext method creates a class declaration for ToolsJsonSerializerContext marked as both public and partial. This aligns with the PR objective of supporting function tools and Google Function Tool integration.

However, there's significant code duplication between this method and the existing GenerateParameterBasedClassSymbol method (lines 16-98). Consider refactoring to extract common code for creating classes, namespaces, and compilation units into a separate helper method.

+ private static INamedTypeSymbol? GenerateTypeSymbol(
+     string rootNamespace,
+     ClassDeclarationSyntax classDecl,
+     Compilation originalCompilation)
+ {
+     var namespaceName = rootNamespace;
+     var ns = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.IdentifierName(namespaceName))
+         .AddMembers(classDecl);
+ 
+     var compilationUnit = SyntaxFactory.CompilationUnit()
+         .AddMembers(ns)
+         .NormalizeWhitespace();
+     
+     var parseOptions = CSharpParseOptions.Default.WithLanguageVersion(originalCompilation.GetLanguageVersion() ?? LanguageVersion.Default);
+     var syntaxTree = CSharpSyntaxTree.Create(compilationUnit, parseOptions);
+ 
+     var compilation = originalCompilation
+         .AddSyntaxTrees(syntaxTree);
+     
+     var semanticModel = compilation.GetSemanticModel(syntaxTree);
+ 
+     var classNode = syntaxTree.GetRoot().DescendantNodes()
+         .OfType<ClassDeclarationSyntax>()
+         .FirstOrDefault();
+ 
+     if (classNode == null) return null;
+ 
+     return semanticModel.GetDeclaredSymbol(classNode);
+ }

Then update both methods to use this helper.

src/libs/CSharpToJsonSchema.Generators/Sources.Tools.cs (1)

94-94: Whitespace adjustment.

This appears to be part of a larger restructuring. Based on the AI summary, the GenerateFunctionToolClientImplementation and GetInputsTypes methods have been removed from this file and a new file (Sources.Method.Tools.cs) was created to handle function tool client implementations.

This restructuring aligns with the PR objective to support individual methods as tools. Consider adding a comment here referencing the new implementation location for better code discoverability.

-   
+   // Function tool client implementation moved to Sources.Method.Tools.cs

src/libs/CSharpToJsonSchema.Generators/JsonGen/JsonSourceGenerator.Roslyn4.0.cs (2)

68-112: Clean up code implementation and remove unnecessary comments.

The InitializeForFunctionTools method correctly mirrors the structure of the existing Initialize2 method, adapting it to work with methods instead of interfaces. However, there are several issues to address:

1. There's an empty line with whitespace on line 91
2. There's a commented-out line on line 97 that should be removed
3. There's a commented-out chained method call on line 105

                .Collect().Select(static (tuple,CancellationToken) =>
                {
-                        
+                        
                        var known = tuple.FirstOrDefault();
                        var knowntype = known.Right;
                        if (knowntype == null && !tuple.Any())
                        {
                            return (null, ImmutableEquatableArray<DiagnosticInfo>.Empty);
-                            //knowntype =new KnownTypeSymbols(tuple.First().Left.SemanticModel.Compilation);
                        }
                        Parser parser = new(knowntype);
                        Model.ContextGenerationSpec? contextGenerationSpec =
                            parser.ParseContextGenerationSpec(tuple,CancellationToken);
                        ImmutableEquatableArray<DiagnosticInfo> diagnostics =
                            parser.Diagnostics.ToImmutableEquatableArray();
                        return (contextGenerationSpec, diagnostics);
-                    })//.Select(sx=>(sx.contextGenerationSpec,sx.contextGenerationSpec))
+                    })

---

94-98: Review conditional logic for clarity and robustness.

The condition knowntype == null && !tuple.Any() is checking two things, but they seem potentially contradictory. If tuple is empty (!tuple.Any()), then knowntype would always be null because known would be default. Consider simplifying this logic.

                        var known = tuple.FirstOrDefault();
                        var knowntype = known.Right;
-                        if (knowntype == null && !tuple.Any())
+                        if (!tuple.Any())
                        {
                            return (null, ImmutableEquatableArray<DiagnosticInfo>.Empty);
                        }

src/libs/CSharpToJsonSchema.Generators/Sources.Method.Tools.cs (3)

23-24: Remove commented-out code.

The commented lines should be removed as they're not providing value and may cause confusion about the current implementation.

-        //var methodName = @interface.Methods.First().Name;
-        //var funcsToAdd = @interface.Methods.Select(GetInputsTypes).Distinct().ToList();

---

47-53: Enhance error handling for function tool registration.

When registering tools, the code correctly checks for duplicates (line 51), but the error handling for duplicate names is only implemented at delegate registration (lines 67-69). Consider adding a more descriptive error message here as well.

            tool = new global::CSharpToJsonSchema.Tool
            {{
                Name = ""{method.Name}"",
                Description = ""{method.Description}"",
                Strict = {(method.IsStrict ? "true" : "false")},
                Parameters = global::CSharpToJsonSchema.SchemaBuilder.ConvertToSchema(global::{@interface.Namespace}.{extensionsClassName}JsonSerializerContext.Default.{method.Name}Args,{"\""}{GetDictionaryString(method)}{"\""}),
            }};
-            if(!list.ContainsKey(tool.Name))
+            if(!list.ContainsKey(tool.Name))
                list.Add(""{method.Name}"",tool);
+            else
+                throw new global::System.Exception({"$\"Function {method.Name} is registered multiple times in the schema definition. Please ensure each function has a unique name.\""});

---

85-88: Simplify the AsTools method implementation.

The current implementation with the null-coalescing assignment operator can be simplified for better readability.

        public global::System.Collections.Generic.List<global::CSharpToJsonSchema.Tool> AsTools()
        {
-            return (global::System.Collections.Generic.List<global::CSharpToJsonSchema.Tool>) (this.AvailableTools??= new global::System.Collections.Generic.List<global::CSharpToJsonSchema.Tool>());
+            if (this.AvailableTools == null)
+            {
+                this.AvailableTools = new global::System.Collections.Generic.List<global::CSharpToJsonSchema.Tool>();
+            }
+            return (global::System.Collections.Generic.List<global::CSharpToJsonSchema.Tool>) this.AvailableTools;
        }

src/tests/CSharpToJsonSchema.AotTests/MethodFunctionTools_Tests.cs (1)

75-76: Remove trailing whitespace.

There is unnecessary whitespace at the end of the test method.

    public async Task Should_SampleFunctionTool_Static_Void()
    {
        var tools = new Tools([MethodFunctionTools.SampleFunctionTool_Static_Void]);
        await tools.CallAsync(nameof(MethodFunctionTools.SampleFunctionTool_Static_Void), "{\"input\":\"test\"}");
-       
    }

src/libs/CSharpToJsonSchema.Generators/Steps.cs (1)

52-60: Improve code formatting for readability.

The formatting of the SelectMany lambda is inconsistent with the rest of the codebase. Consider standardizing the indentation and line breaks for better readability.

        var items = source
-            .SelectMany(static (context, _) => 
-                context.Attributes
-                .Select(x => 
-                (
-                    context.SemanticModel,
-                    AttributeData: x,
-                    ClassSyntax: (MethodDeclarationSyntax)context.TargetNode,
-                    ClassSymbol: (IMethodSymbol)context.TargetSymbol)
-                )).Collect();
+            .SelectMany(static (context, _) => context.Attributes
+                .Select(x => (
+                    context.SemanticModel,
+                    AttributeData: x,
+                    ClassSyntax: (MethodDeclarationSyntax)context.TargetNode,
+                    ClassSymbol: (IMethodSymbol)context.TargetSymbol)))
+            .Collect();

src/libs/CSharpToJsonSchema.Generators/Sources.Method.GoogleFunctionTools.cs (1)

38-39: Risk of substring out-of-range on interface names not prefixed with "I".
Using Substring(1) presumes that the interface name always starts with "I". This could trigger an exception for unusual interface names.

- var extensionsClassName = @interface.Name.Substring(startIndex: 1) + "Extensions";
+ var extensionsClassName = @interface.Name.StartsWith("I") && @interface.Name.Length > 1
+     ? @interface.Name.Substring(1) + "Extensions"
+     : @interface.Name + "Extensions";

src/libs/CSharpToJsonSchema.Generators/Conversion/ToModels.cs (2)

48-48: Property assignment in InterfaceData.
Setting GoogleFunctionTool as part of InterfaceData is straightforward. Consider documenting how it is used downstream for clarity.

---

53-98: Method-based interface data preparation.
The new PrepareMethodData method enumerates methods with their attributes. This is an effective approach for collecting data. Validate that skipping CancellationToken is intentional or re-apply the filter if needed.

src/libs/CSharpToJsonSchema.Generators/JsonGen/JsonSourceGenerator.Parser.cs (4)

229-278: Partial class checks in TryGetNestedTypeDeclarations.
Creating a default tools context declaration if the partial class or interface signature isn't found is a clever fallback. Just be sure partial definitions are consistently recognized across user code.

---

606-607: Appended "JsonSerializerContext" naming.
Appending "JsonSerializerContext" to the base name can be beneficial for clarity, though watch for possible naming collisions when the user code already ends with "Context."

---

791-832: Method-based attribute parsing.
Leveraging GenerateParameterBasedClassSymbol for method arguments is a flexible approach, especially for generating types on the fly. Ensure that any advanced generic parameters or constraints on these methods are handled properly.

---

966-1108: Parsing JsonSourceGenerationOptionsAttribute.
This extensive parsing logic thoroughly covers each property. Consider documenting how advanced scenarios (like custom policies or converters) might be extended or overridden if future requirements emerge.

src/libs/CSharpToJsonSchema.Generators/JsonSchemaGenerator.cs (3)

46-53: Consider consolidating repeated patterns.

Both AsFunctionCalls and AsGoogleFunctionToolsForMethods follow a similar pattern of SelectAndReportExceptions(...).AddSource(context). You might consider unifying these calls in one chain or function to reduce verbosity.

---

54-55: Ensure consistent initialization naming.

InitializeForFunctionTools(context) differs from Initialize2(context) used in ProcessInterfaces. Consider adopting consistent naming (e.g. InitializeForFunctionTools/InitializeForInterfaces) to reduce confusion for future maintainers.

---

90-95: Clarify the returned type.

PrepareMethodData returns an InterfaceData even though it processes method-specific data. Although functional, consider extracting a more precise type name (e.g., MethodData) if feasible, to improve clarity.

src/tests/CSharpToJsonSchema.AotTests/Services/MethodFunctionTools.cs (1)

8-55: Unused inputs and cancellation tokens.

All methods ignore the input parameter and do not utilize their CancellationToken. If this is a placeholder, it's fine; otherwise, consider using or removing these parameters to avoid confusion.

src/tests/CSharpToJsonSchema.IntegrationTests/MethodFunctionTools.cs (1)

9-56: Parameters are consistently unused.

All instance/static methods return hardcoded strings or complete tasks without leveraging input or CancellationToken. Confirm this is intentional. Removing or handling these parameters can improve clarity.

src/libs/CSharpToJsonSchema.Generators/Sources.Method.Calls.cs (3)

99-128: Use of dynamic may affect performance and type safety.

Relying on (dynamic)Delegates[...] could result in runtime issues if signatures or keys change. Consider strongly typed delegates for safer refactoring.

---

139-172: Async method invocation with dynamic.

Similar to the non-async approach, dynamic can introduce runtime errors. Consider stronger typing to ensure correctness.

---

189-198: Run-time dictionary lookups in CallAsync.

CallAsync presumes functionName always matches a valid dictionary entry. If user input can vary, consider robust error handling.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro